package com.robotic.sensor.service;

import java.math.BigDecimal;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import com.robotic.sensor.domain.RegionStandard;
import com.robotic.sensor.domain.SensorData;

/**
 * 传感器数据判断服务类
 * 根据区域标准判断传感器数据是否符合要求
 * 
 * @author robotic
 * @date 2024-01-20
 */
@Service
public class SensorDataJudgementService
{
    private static final Logger log = LoggerFactory.getLogger(SensorDataJudgementService.class);

    /**
     * 判断传感器数据是否符合区域标准
     * 
     * @param sensorData 传感器数据
     * @param regionStandard 区域标准配置
     * @return 判断结果
     */
    public boolean judge(SensorData sensorData, RegionStandard regionStandard)
    {
        if (sensorData == null || regionStandard == null)
        {
            log.warn("传感器数据或区域标准配置为空，无法进行判断");
            return false;
        }

        BigDecimal value = sensorData.getValue();
        if (value == null)
        {
            log.warn("传感器数据值为空，无法进行判断");
            sensorData.setDetectStatus("unknown");
            sensorData.setIsStandard("0");
            return false;
        }

        // 获取检测状态
        String detectStatus = regionStandard.getDetectStatus(value);
        sensorData.setDetectStatus(detectStatus);

        // 判断是否符合标准（只有正常状态才算符合标准）
        boolean isStandard = "normal".equals(detectStatus);
        sensorData.setIsStandard(isStandard ? "1" : "0");

        // 记录判断日志
        log.info("传感器数据判断完成 - 区域: {}, 类型: {}, 值: {}, 状态: {}, 是否符合标准: {}", 
                sensorData.getRegionCode(), 
                sensorData.getSensorType(), 
                value, 
                detectStatus, 
                isStandard ? "是" : "否");

        return isStandard;
    }

    /**
     * 批量判断传感器数据
     * 
     * @param sensorDataList 传感器数据列表
     * @param regionStandard 区域标准配置
     * @return 符合标准的数据数量
     */
    public int batchJudge(java.util.List<SensorData> sensorDataList, RegionStandard regionStandard)
    {
        if (sensorDataList == null || sensorDataList.isEmpty())
        {
            log.warn("传感器数据列表为空，无法进行批量判断");
            return 0;
        }

        int standardCount = 0;
        for (SensorData sensorData : sensorDataList)
        {
            if (judge(sensorData, regionStandard))
            {
                standardCount++;
            }
        }

        log.info("批量判断完成 - 总数: {}, 符合标准: {}, 异常数: {}", 
                sensorDataList.size(), standardCount, sensorDataList.size() - standardCount);

        return standardCount;
    }

    /**
     * 判断传感器数据并生成处理建议
     * 
     * @param sensorData 传感器数据
     * @param regionStandard 区域标准配置
     * @return 处理建议
     */
    public String judgeWithAdvice(SensorData sensorData, RegionStandard regionStandard)
    {
        boolean isStandard = judge(sensorData, regionStandard);
        
        if (isStandard)
        {
            return "传感器数据正常，继续执行任务";
        }

        String detectStatus = sensorData.getDetectStatus();
        String advice = "";
        
        switch (detectStatus)
        {
            case "warning":
                advice = "传感器数据异常（警告级别），建议加强监控，可继续执行任务";
                break;
            case "danger":
                advice = "传感器数据异常（危险级别），建议立即停止任务并进行安全检查";
                break;
            case "unknown":
                advice = "传感器数据状态未知，建议检查传感器设备和配置";
                break;
            default:
                advice = "传感器数据异常，建议进行详细检查";
                break;
        }

        log.warn("传感器数据异常处理建议 - 区域: {}, 类型: {}, 值: {}, 建议: {}", 
                sensorData.getRegionCode(), 
                sensorData.getSensorType(), 
                sensorData.getValue(), 
                advice);

        return advice;
    }

    /**
     * 检查传感器数据是否需要紧急处理
     * 
     * @param sensorData 传感器数据
     * @return true-需要紧急处理，false-不需要紧急处理
     */
    public boolean needsUrgentHandling(SensorData sensorData)
    {
        if (sensorData == null)
        {
            return false;
        }

        // 危险状态需要紧急处理
        boolean isDanger = sensorData.isDangerStatus();
        
        if (isDanger)
        {
            log.error("检测到危险状态的传感器数据，需要紧急处理 - 区域: {}, 类型: {}, 值: {}", 
                    sensorData.getRegionCode(), 
                    sensorData.getSensorType(), 
                    sensorData.getValue());
        }

        return isDanger;
    }

    /**
     * 获取传感器数据的风险等级
     * 
     * @param sensorData 传感器数据
     * @return 风险等级 (1-低风险, 2-中风险, 3-高风险)
     */
    public int getRiskLevel(SensorData sensorData)
    {
        if (sensorData == null || sensorData.getDetectStatus() == null)
        {
            return 0; // 未知风险
        }

        switch (sensorData.getDetectStatus())
        {
            case "normal":
                return 1; // 低风险
            case "warning":
                return 2; // 中风险
            case "danger":
                return 3; // 高风险
            default:
                return 0; // 未知风险
        }
    }

    /**
     * 生成传感器数据判断报告
     * 
     * @param sensorData 传感器数据
     * @param regionStandard 区域标准配置
     * @return 判断报告
     */
    public String generateJudgementReport(SensorData sensorData, RegionStandard regionStandard)
    {
        if (sensorData == null || regionStandard == null)
        {
            return "无法生成报告：传感器数据或区域标准配置为空";
        }

        StringBuilder report = new StringBuilder();
        report.append("=== 传感器数据判断报告 ===\n");
        report.append("检测时间: ").append(sensorData.getDetectTime()).append("\n");
        report.append("区域代码: ").append(sensorData.getRegionCode()).append("\n");
        report.append("传感器类型: ").append(sensorData.getSensorType()).append("\n");
        report.append("检测值: ").append(sensorData.getValue()).append(" ").append(regionStandard.getUnit()).append("\n");
        report.append("检测状态: ").append(sensorData.getDetectStatus()).append("\n");
        report.append("是否符合标准: ").append("1".equals(sensorData.getIsStandard()) ? "是" : "否").append("\n");
        report.append("风险等级: ").append(getRiskLevel(sensorData)).append("\n");
        
        if (regionStandard.getNormalMin() != null && regionStandard.getNormalMax() != null)
        {
            report.append("正常范围: ").append(regionStandard.getNormalMin()).append(" - ").append(regionStandard.getNormalMax()).append("\n");
        }
        
        if (regionStandard.getWarningMin() != null && regionStandard.getWarningMax() != null)
        {
            report.append("警告范围: ").append(regionStandard.getWarningMin()).append(" - ").append(regionStandard.getWarningMax()).append("\n");
        }
        
        if (regionStandard.getDangerMin() != null && regionStandard.getDangerMax() != null)
        {
            report.append("危险范围: < ").append(regionStandard.getDangerMin()).append(" 或 > ").append(regionStandard.getDangerMax()).append("\n");
        }
        
        report.append("处理建议: ").append(judgeWithAdvice(sensorData, regionStandard)).append("\n");
        report.append("========================\n");

        return report.toString();
    }
}